package cn.vconinfo.base.utils;

import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.lang3.StringUtils;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * <p>
 * 字符串工具类
 *
 * @author : microspeed
 * @version : V1.0
 * @since : 2019年5月27日 下午4:57:31
 */
public class StringUtil {
    private static Pattern cnPattern = Pattern.compile("[\u4e00-\u9fa5]");
    private static Pattern htmlPattern = Pattern.compile("<[^<|^>]*>");

    private StringUtil() throws IllegalAccessException {
        throw new IllegalAccessException("Utils类不可实例化");
    }

    /**
     * 如果value为空或为null 返回null 否则返回value本身
     *
     * @param value String
     * @return String
     */
    public static String getNull(String value) {
        if (isEmpty(value)) {
            return null;
        }
        return value;
    }

    /**
     * Method 取对象的ToString值.
     *
     * @param obj char
     * @return String
     */
    public static String getThisString(char obj) {
        Character c = new Character(obj);
        return c.toString();
    }

    /**
     * Method 取对象的ToString值.
     *
     * @param obj int
     * @return String
     */
    public static String getThisString(int obj) {
        String sobjString = "";
        sobjString = Integer.toString(obj);
        sobjString.trim();
        return sobjString;
    }

    /**
     * Method 取对象的ToString值.
     *
     * @param obj Object
     * @return String
     */
    public static String getThisString(Object obj) {
        String sobjString = "";
        if (obj != null) {
            sobjString = obj.toString().trim();
        }
        return sobjString;
    }

    /**
     * 如果空值返回指定的替换值，否则返回原值。
     *
     * @param strFrom    源字符串
     * @param strReplace 替换字符串
     * @return 返回字符串
     */
    public static String ifNull(String strFrom, String strReplace) {
        if (strFrom == null) {
            return strReplace;
        } else {
            return strFrom;
        }
    }

    /**
     * 返回指定字符串全部被替换后的结果
     *
     * @param strFrom    源字符串
     * @param strFind    被替换字符串(如果为null不作替换)
     * @param strReplace 替换成字符串(如果为null不作替换)
     * @return 返回字符串
     * <p>
     *
     * <pre class="code">
     * 执行案例：
     * YrsStringUtils.replaceAll(null, *, *)        = null
     * YrsStringUtils.replaceAll("", *, *)          = ""
     * YrsStringUtils.replaceAll("any", null, *)    = "any"
     * YrsStringUtils.replaceAll("any", *, null)    = "any"
     * YrsStringUtils.replaceAll("any", "", *)      = "any"
     * YrsStringUtils.replaceAll("aba", "a", null)  = "aba"
     * YrsStringUtils.replaceAll("aba", "a", "")    = "b"
     * YrsStringUtils.replaceAll("aba", "a", "z")   = "zbz"
     *         </pre>
     */
    public static String replaceAll(String strFrom, String strFind, String strReplace) {
        return StringUtils.replace(strFrom, strFind, strReplace);
    }

    /**
     * 返回指定字符串只被替换一次后的结果
     *
     * @param strFrom    源字符串
     * @param strFind    被替换字符串(如果为null不作替换)
     * @param strReplace 替换成字符串(如果为null不作替换)
     * @return 返回字符串
     * <p>
     *
     * <pre class="code">
     * 执行案例：
     * YrsStringUtils.replaceOnce(null, *, *)        = null
     * YrsStringUtils.replaceOnce("", *, *)          = ""
     * YrsStringUtils.replaceOnce("any", null, *)    = "any"
     * YrsStringUtils.replaceOnce("any", *, null)    = "any"
     * YrsStringUtils.replaceOnce("any", "", *)      = "any"
     * YrsStringUtils.replaceOnce("aba", "a", null)  = "aba"
     * YrsStringUtils.replaceOnce("aba", "a", "")    = "ba"
     * YrsStringUtils.replaceOnce("aba", "a", "z")   = "zba"
     *         </pre>
     */
    public static String replaceOnce(String strFrom, String strFind, String strReplace) {
        return StringUtils.replaceOnce(strFrom, strFind, strReplace);
    }

    /**
     * 去除指定字符串中的回车换行
     *
     * @param str 指定字符串
     * @return 去除回车换行后的字符串
     */
    public static String replaceEnter(String str) {
        if (str == null) {
            return null;
        }
        return str.replaceAll("\r", "").replaceAll("\n", "");
    }

    /**
     * 返回用指定字符串分隔后的字符串数组
     *
     * @param strFrom  源字符串
     * @param strSplit 指定分隔字符串
     * @return 分隔后的字符串数组
     */
    public static String[] strSplit(String strFrom, String strSplit) {
        return StringUtils.split(strFrom, strSplit);
    }

    /**
     * 检测某字符串数组中是否存在某字符串
     *
     * @param strValue 字符串
     * @param strArray 字符串数组
     * @return 存在返回真，不存在返回假
     */
    public static boolean isInArray(String strValue, String[] strArray) {

        if (strArray == null) {
            return false;
        }
        for (String v : strArray) {
            if (v.equals(strValue)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 检测某字符串数组中是否存在某数字
     *
     * @param intValue 数字
     * @param strArray 字符串数组
     * @return 存在返回真，不存在返回假
     */
    public static boolean isInArray(int intValue, String[] strArray) {
        // if (strArray == null)
        // return false;
        // for (String v : strArray) {
        // if (Integer.valueOf(v).intValue() == intValue)
        // return true;
        // }
        // return false;
        return isInArray(Integer.toString(intValue), strArray);
    }

    /**
     * 验证输入是否手机号
     *
     * @param phone 待验证的字符串
     * @return 是手机号返回true 否则false
     *
     * <p>
     *
     * <pre class="code">
     * 中国电信号段 133、149、153、173、177、180、181、189、199
     * 中国联通号段 130、131、132、145、155、156、166、175、176、185、186
     * 中国移动号段 134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188、198
     * 其他号段
     * 14号段以前为上网卡专属号段，如中国联通的是145，中国移动的是147等等。
     * 虚拟运营商
     * 电信：1700、1701、1702
     * 移动：1703、1705、1706
     * 联通：1704、1707、1708、1709、171
     * 卫星通信：1349
     *         </pre>
     */
    public static boolean validateMoblie(String phone) {
        String regex = "^((13[0-9])|(14[5,7,9])|(15([0-3]|[5-9]))|(166)|(17[0,1,3,5,6,7,8])|(18[0-9])|(19[8|9]))\\d{8}$";
        if (phone.length() != 11) {
            return false;
        } else {
            Pattern p = Pattern.compile(regex);
            Matcher m = p.matcher(phone);
            return m.matches();
        }

        // int l = phone.length();
        // boolean rs = false;
        // switch (l) {
        // case 7:
        // if (matchingText("^(13[0-9]|15[0-9]|18[7|8|9|6|5])\\d{4}$", phone)) {
        // rs = true;
        // }
        // break;
        // case 11:
        // if (matchingText("^(13[0-9]|15[0-9]|18[7|8|9|6|5])\\d{4,8}$", phone))
        // {
        // rs = true;
        // }
        // break;
        // default:
        // rs = false;
        // break;
        // }
        // return rs;
    }

    /**
     * 字符串是否符合正则表达式
     *
     * @param expression 正则表达式
     * @param text       字符串
     * @return 符合返回真，不符合返回假
     */
    public static boolean matchingText(String expression, String text) {
        Pattern p = Pattern.compile(expression); // 正则表达式
        Matcher m = p.matcher(text); // 操作的字符串
        boolean b = m.matches();
        return b;
    }

    /**
     * 返回一个由数组元素组合成的字符串(可指定间隔符)
     *
     * @param strSplit 间隔字符串
     * @param array    数组
     * @return 连接后字符串
     */
    public static String implode(String strSplit, Object[] array) {
        if (strSplit == null || array == null) {
            return "";
        }
        String result = "";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                result += array[i].toString();
            } else {
                result += array[i].toString() + strSplit;
            }
        }
        return result;
    }

    /**
     * MD5加密方法
     *
     * @param strFrom 加密前字符串
     * @return 加密后字符串
     */
    public static String md5(String strFrom) {
        MessageDigest messageDigest = null;
        try {
            messageDigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
            return null;
        }
        byte[] resultByte = messageDigest.digest(strFrom.getBytes());
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < resultByte.length; ++i) {
            result.append(Integer.toHexString(0xFF & resultByte[i]));
        }
        return result.toString();
    }

    /**
     * 验证Email地址是否有效
     *
     * @param strEmail Email地址字符串
     * @return 如果有效返回true，如果无效返回false
     */
    public static boolean validEmail(String strEmail) {
        String pattern = "^([a-z0-9A-Z]+[-|\\.|_]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        return strEmail.matches(pattern);
    }

    /**
     * 验证字符串长度是否不超过指定最大长度
     *
     * @param str    字符串
     * @param length 最大长度
     * @return 如果不超过返回true，否则返回false
     */
    public static boolean validMaxLen(String str, int length) {
        if (str == null) {
            return true;
        }
        if (str.length() <= length) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 验证字符串长度是否大于等于最小长度
     *
     * @param str    字符串
     * @param length 最小长度
     * @return 如果大于等于指定长度返回true，否则返回false
     */
    public static boolean validMinLen(String str, int length) {
        if (str == null) {
            return true;
        }
        if (str.length() >= length) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 验证一个字符串是否为空
     *
     * @param str 字符
     * @return 如果为空返回真，如果不为空返回假
     */
    public static boolean isEmpty(String str) {
        if (str == null || str.trim().isEmpty()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 校验对象是否为空
     *
     * @param obj
     * @return
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        return isEmpty(obj.toString());
    }

    /**
     * 得到WEB-INF的绝对路径
     *
     * @return WEB-INF的绝对路径
     */
    public static String getWebInfPath() {
        String filePath = Thread.currentThread().getContextClassLoader().getResource("").toString();
        if (filePath.toLowerCase().indexOf("file:") > -1) {
            filePath = filePath.substring(6, filePath.length());
        }
        if (filePath.toLowerCase().indexOf("classes") > -1) {
            filePath = filePath.replaceAll("/classes", "");
        }
        if (System.getProperty("os.name").toLowerCase().indexOf("window") < 0) {
            filePath = "/" + filePath;
        }
        if (!filePath.endsWith("/")) {
            filePath += "/";
        }
        return filePath;
    }

    /**
     * 得到根目录绝对路径(不包含WEB-INF)
     *
     * @return 根目录绝对路径(不包含WEB - INF)
     */
    public static String getRootPath() {
        // return "E:/javatool/apache-tomcat-6.0.18/webapps/user_test";
        String filePath = Thread.currentThread().getContextClassLoader().getResource("").toString();
        if (filePath.toLowerCase().indexOf("file:") > -1) {
            filePath = filePath.substring(6, filePath.length());
        }
        if (filePath.toLowerCase().indexOf("classes") > -1) {
            filePath = filePath.replaceAll("/classes", "");
        }
        if (filePath.toLowerCase().indexOf("web-inf") > -1) {
            filePath = filePath.substring(0, filePath.length() - 9);
        }
        if (System.getProperty("os.name").toLowerCase().indexOf("window") < 0) {
            filePath = "/" + filePath;
        }

        if (filePath.endsWith("/")) {
            filePath = filePath.substring(0, filePath.length() - 1);
        }

        return filePath;
    }

    public static String getRootPath(String resource) {
        String filePath = Thread.currentThread().getContextClassLoader().getResource(resource).toString();
        if (filePath.toLowerCase().indexOf("file:") > -1) {
            filePath = filePath.substring(6, filePath.length());
        }
        // if (filePath.toLowerCase().indexOf("classes") > -1) {
        // filePath = filePath.replaceAll("/classes", "");
        // }
        // if (filePath.toLowerCase().indexOf("web-inf") > -1) {
        // filePath = filePath.substring(0, filePath.length() - 9);
        // }
        if (System.getProperty("os.name").toLowerCase().indexOf("window") < 0) {
            filePath = "/" + filePath;
        }

        if (!filePath.endsWith("/")) {
            filePath += "/";
        }

        return filePath;
    }

    /**
     * 截取字符串originStr中指定字符 strStart、strEnd之间的字符串
     *
     * @param originStr 源字符串
     * @param strStart  指定开始字串
     * @param strEnd    指定结束字串
     * @return 返回截取后字符串
     */
    public static String getIntervalStr(String originStr, String strStart, String strEnd) {

        /* 找出指定的2个字符在 该字符串里面的 位置 */
        int strStartIndex = originStr.indexOf(strStart);
        /* index 为负数 即表示该字符串中 没有该字符 */
        if (strStartIndex < 0) {
            return "";
        }

        int strEndIndex = originStr.indexOf(strEnd);
        if (strEndIndex < 0) {
            return "";
        }
        try {
            /* 开始截取 */
            String intervalStr = originStr.substring(strStartIndex, strEndIndex).substring(strStart.length());
            return intervalStr;
        } catch (StringIndexOutOfBoundsException e) {
            return "";
        }
    }

    /**
     * 格式化页码（字符串转换成数字）
     *
     * @param page 页码
     * @return 页码数字，如果页码不为数字，则返回1
     */
    public static int formatPage(String page) {
        int iPage = 1;
        if (page == null || page.equals("")) {
            return iPage;
        }
        try {
            iPage = Integer.parseInt(page);
        } catch (Exception ex) {
            iPage = 1;
        }
        return iPage;
    }

    /**
     * 将文件大小自动转换为相应计量单位
     *
     * @param fileSize 文件大小数字
     * @return 转换为相应单位后数字+单位
     */
    public static String getFileSize(String fileSize) {
        String temp = "";
        DecimalFormat df = new DecimalFormat("0.00");
        double dbFileSize = Double.parseDouble(fileSize);
        if (dbFileSize >= 1024) {
            if (dbFileSize >= 1048576) {
                if (dbFileSize >= 1073741824) {
                    temp = df.format(dbFileSize / 1024 / 1024 / 1024) + " GB";
                } else {
                    temp = df.format(dbFileSize / 1024 / 1024) + " MB";
                }
            } else {
                temp = df.format(dbFileSize / 1024) + " KB";
            }
        } else {
            temp = df.format(dbFileSize) + " B";
        }
        return temp;
    }

    /**
     * 得到一个32位随机字符
     *
     * @return 32位随机字符
     * <p>
     * 结果示例:9976fccdda999efe2230e336ffc576
     */
    public static String getEntry() {
        Random random = new Random(100);
        Date now = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat(new String("yyyyMMddHHmmssS"));
        return md5(formatter.format(now) + random.nextDouble());
    }

    /**
     * 将字符串转成UTF8编码
     *
     * @param str 字符串
     * @return UTF编码字符串
     */
    public static String toUTF8(String str) {
        if (str == null || str.equals("")) {
            return "";
        }
        try {
            return new String(str.getBytes("ISO8859-1"), "UTF-8");
        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
    }

    /**
     * 将中文汉字转成指定编码
     *
     * @param str     字符串
     * @param charset 指定编码
     * @return 转换后指定编码字符串
     */
    public static String toCode(String str, String charset) {
        if (str == null || str.equals("")) {
            return "";
        }
        try {
            return new String(str.getBytes("ISO8859-1"), charset);
        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
    }

    /**
     * 得到一个指定位数随机数字字串
     *
     * @param n 指定位数
     * @return 指定位数随机数字字串
     * <p>
     * 结果示例:919001
     */
    public static String getRandInt(int n) {
        Random random = new Random();
        String strRand = "";
        for (int i = 0; i < n; i++) {
            strRand += String.valueOf(random.nextInt(10));
        }
        return strRand;
    }

    /**
     * 得到一个切去指定头部字符串后的字符串
     *
     * @param originStr 源字符串
     * @param prefix    切去字符串
     * @return 切去后字符串
     */
    public static String trimHead(String originStr, String prefix) {
        if (originStr != null && prefix != null && originStr.startsWith(prefix)) {
            return originStr.substring(prefix.length());
        } else {
            return originStr;
        }
    }

    /**
     * 得到一个切去指定尾部字符串后的字符串
     *
     * @param originStr 源字符串
     * @param suffix    切去字符串
     * @return 切去后字符串
     */
    public static String trimTail(String originStr, String suffix) {
        if (originStr != null && suffix != null && originStr.endsWith(suffix)) {
            return originStr.substring(0, originStr.length() - suffix.length());
        } else {
            return originStr;
        }
    }

    /**
     * 得到一个数字的大写(一到十之内)
     *
     * @param num 数字
     * @return 对应大写值
     */
    public static String getChineseNum(int num) {
        String[] chineseNum = new String[]{"一", "二", "三", "四", "五", "六", "七", "八", "九", "十"};
        return chineseNum[num];
    }

    /**
     * 去除HTML元素
     *
     * @param element 源文本
     * @return 去除HTML元素后文本
     */
    public static String getTxtWithoutHTMLElement(String element) {

        if (null == element || "".equals(element.trim())) {
            return element;
        }
        Matcher matcher = htmlPattern.matcher(element);
        StringBuffer txt = new StringBuffer();
        while (matcher.find()) {
            String group = matcher.group();
            if (group.matches("<[\\s]*>")) {
                matcher.appendReplacement(txt, group);
            } else {
                matcher.appendReplacement(txt, "");
            }
        }
        matcher.appendTail(txt);
        String temp = txt.toString().replaceAll("\n", "");
        temp = temp.replaceAll(" ", "");
        return temp;
    }

    /**
     * @param originStr 源字符串
     * @return 去首尾空格后字符串
     */
    public static String trimSpace(String originStr) {
        if (originStr != null) {
            return originStr.replaceAll("　", "").trim();
        }
        return "";
    }

    /**
     * convert obj to String
     *
     * @param obj 源对象
     * @return 转换后字符串
     */
    public static String objToStr(Object obj) {
        String result = "";
        if (obj != null) {
            result = obj.toString();
        }
        return result;
    }

    /**
     * 转义字串的$
     *
     * @param str 源字符串
     * @return 转义后字符串
     *
     * <p>
     * 示例:"ab$cd$eabcde" -&gt; "ab\$cd\$eabcde"
     */
    public static String filterDollarStr(String str) {
        String sReturn = "";
        if (!isEmpty(str)) {
            if (str.indexOf('$', 0) > -1) {
                while (str.length() > 0) {
                    if (str.indexOf('$', 0) > -1) {
                        sReturn += str.subSequence(0, str.indexOf('$', 0));
                        sReturn += "\\$";
                        str = str.substring(str.indexOf('$', 0) + 1, str.length());
                    } else {
                        sReturn += str;
                        str = "";
                    }
                }
            }
        }
        return sReturn;
    }

    /**
     * 压缩HTML文本
     *
     * @param html HTML文本
     * @return 压缩后HTML文本
     */
    public static String compressHtml(String html) {
        if (html == null)
            return null;

        html = html.replaceAll("[\\t\\n\\f\\r]", "");
        return html;
    }

    /**
     * 金额标准格式化
     *
     * @param money 金额
     * @return 标准格式化后金额
     */
    public static String toCurrency(Double money) {
        if (money != null) {
            DecimalFormat df = new DecimalFormat("￥#,###.00");
            return df.format(money);
        }
        return "";
    }

    /**
     * 获取分页字符串
     *
     * @param totalCount 总记录数
     * @param pageUrl    不带页参的url
     * @param pageCount  页数
     * @param pageSize   每页记录数
     * @param curPageNo  当前页
     * @param param      where条件:&amp;spbm=22&amp;spmc=33
     * @return 分页字符串
     */
    public static String getNewPagestr(Integer totalCount, String pageUrl, Integer pageCount, Integer pageSize,
                                       Integer curPageNo, String param) {
        StringBuffer sb = new StringBuffer();
        param = param.trim();
        if ("-".equals(param)) {
            param = "";
        }
        pageUrl = pageUrl.replaceAll(".jhtml", "");
        if (pageCount <= 1) {
            return "";
        }
        curPageNo = curPageNo < 1 ? 1 : curPageNo;
        String next_str = "";
        String pre_str = "";
        boolean b = false;
        boolean c = false;
        for (int i = 1; i <= pageCount; i++) {
            if (curPageNo > 1) {
                pre_str = "<a href=\"" + pageUrl + "-" + pageSize + "-" + (curPageNo - 1) + "" + param
                        + ".jhtml\" class=\"prev\">上一页</a>\n";
            }
            if (curPageNo == i) {
                sb.append("<a href=\"#\" class=\"cur\">" + i + "</a>\n");
            } else {
                if (i == 1 || i == pageCount || (i > curPageNo && i <= curPageNo + 2)
                        || (i >= curPageNo - 2 && i < curPageNo)) {
                    sb.append("<a href=\"" + pageUrl + "-" + pageSize + "-" + i + "" + param + ".jhtml\">" + i
                            + "</a>\n");
                } else {
                    if (i <= curPageNo - 2) {
                        if (!b) {
                            sb.append("<span>……</span>\n");
                            b = true;
                        }
                    }
                    if (i > curPageNo + 2) {
                        if (!c) {
                            sb.append("<em>…</em>\n");
                            c = true;
                        }
                    }
                }
            }
            if (i > 1 && pageCount > curPageNo) {
                next_str = "<a href=\"" + pageUrl + "-" + pageSize + "-" + (curPageNo + 1) + "" + param
                        + ".jhtml\" class=\"next\">下一页</a>\n";
            }
        }

        return pre_str + sb.toString() + next_str;
    }

    /**
     * 获取分页字符串
     *
     * @param totalCount 总记录数
     * @param pageUrl    不带页参的url
     * @param pageCount  页数
     * @param pageSize   每页记录数
     * @param curPageNo  当前页
     * @param param      where条件:&amp;spbm=22&amp;spmc=33
     * @return 分页字符串
     */
    public static String getNextPagestr(Integer totalCount, String pageUrl, Integer pageCount, Integer pageSize,
                                        Integer curPageNo, String param) {
        StringBuffer sb = new StringBuffer();
        param = param.trim();
        if (pageCount <= 1) {
            return "";
        }
        curPageNo = curPageNo < 1 ? 1 : curPageNo;
        String next_str = "";
        String pre_str = "";
        boolean b = false;
        boolean c = false;
        for (int i = 1; i <= pageCount; i++) {
            if (curPageNo > 1) {
                pre_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo - 1) + "" + param
                        + "\" class=\"prev\">上一页</a> \n";
            }
            if (curPageNo == i) {
                sb.append("<a href=\"javascript:void(0)\" class=\"cur\">" + i + "</span>\n");
            } else {
                if (i == 1 || i == pageCount || (i > curPageNo && i <= curPageNo + 2)
                        || (i >= curPageNo - 2 && i < curPageNo)) {
                    sb.append("<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + i + "" + param + "\" >"
                            + i + "</a>\n");
                } else {
                    if (i <= curPageNo - 2) {
                        if (!b) {
                            sb.append("<em>…</em>\n");
                            b = true;
                        }
                    }
                    if (i > curPageNo + 2) {
                        if (!c) {
                            sb.append("<em>…</em>\n");
                            c = true;
                        }
                    }
                }
            }
            if (i > 1 && pageCount > curPageNo) {
                next_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo + 1) + "" + param
                        + "\" class=\"next\">下一页</a> \n";
            }
        }

        return pre_str + sb.toString() + next_str;
    }

    /**
     * 获取分页字符串
     *
     * @param totalCount 总记录数
     * @param pageUrl    不带页参的url
     * @param pageCount  页数
     * @param pageSize   每页记录数
     * @param curPageNo  当前页
     * @param param      where条件:&amp;spbm=22&amp;spmc=33
     * @return 分页字符串
     */
    public static String getPagestr(Integer totalCount, String pageUrl, Integer pageCount, Integer pageSize,
                                    Integer curPageNo, String param) {
        StringBuffer sb = new StringBuffer();
        param = param.trim();
        if (pageCount <= 1) {
            return "";
        }
        curPageNo = curPageNo < 1 ? 1 : curPageNo;
        String next_str = "";
        String pre_str = "";
        boolean b = false;
        boolean c = false;
        for (int i = 1; i <= pageCount; i++) {
            if (curPageNo > 1) {
                pre_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo - 1) + "" + param
                        + "\" hidefocus=\"hidefocus\">上一页</a> \n";
            }
            if (curPageNo == i) {
                sb.append("<span class=\"current\">" + i + "</span>\n");
            } else {
                if (i == 1 || i == pageCount || (i > curPageNo && i <= curPageNo + 2)
                        || (i >= curPageNo - 2 && i < curPageNo)) {
                    sb.append("<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + i + "" + param
                            + "\" hidefocus=\"hidefocus\">" + i + "</a>\n");
                } else {
                    if (i <= curPageNo - 2) {
                        if (!b) {
                            sb.append("<em>…</em>\n");
                            b = true;
                        }
                    }
                    if (i > curPageNo + 2) {
                        if (!c) {
                            sb.append("<em>…</em>\n");
                            c = true;
                        }
                    }
                }
            }
            if (i > 1 && pageCount > curPageNo) {
                next_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo + 1) + "" + param
                        + "\" hidefocus=\"hidefocus\">下一页</a> \n";
            }
        }

        return pre_str + sb.toString() + next_str;
    }

    /**
     * 获取分页字符串
     *
     * @param pageUrl   不带页参的url
     * @param pageCount 页数
     * @param pageSize  每页记录数
     * @param curPageNo 当前页
     * @param param     where条件:&amp;spbm=22&amp;spmc=33
     * @return 分页字符串
     */
    public static String getListPagestr(String pageUrl, Integer pageCount, Integer pageSize, Integer curPageNo,
                                        String param) {
        StringBuffer sb = new StringBuffer();
        param = param.trim();

        if (pageCount <= 1) {
            return "";
        }
        curPageNo = curPageNo < 1 ? 1 : curPageNo;
        String next_str = "";
        String pre_str = "";
        boolean b = false;
        boolean c = false;
        for (int i = 1; i <= pageCount; i++) {
            if (curPageNo > 1) {
                pre_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo - 1) + "" + param
                        + "\" hidefocus=\"hidefocus\">上一页</a> \n";
            }
            if (curPageNo == i) {
                // sb.append("<a
                // href=\""+PageUrl+"?pgSize="+pageSize+"&pgNumber="+i+""+param+"\"
                // hidefocus=\"hidefocus\">"+i+"</a>\n");

                sb.append("<span class=\"current\">" + i + "</span>\n");
            } else {
                if (i == 1 || i == pageCount || (i > curPageNo && i <= curPageNo + 2)
                        || (i >= curPageNo - 2 && i < curPageNo)) {
                    sb.append("<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + i + "" + param
                            + "\" hidefocus=\"hidefocus\">" + i + "</a>\n");
                } else {
                    if (i <= curPageNo - 2) {
                        if (!b) {
                            sb.append("<em>…</em>\n");
                            b = true;
                        }
                    }
                    if (i > curPageNo + 2) {
                        if (!c) {
                            sb.append("<em>…</em>\n");
                            c = true;
                        }
                    }
                }
            }
            if (i > 1 && pageCount > curPageNo) {
                next_str = "<a href=\"" + pageUrl + "?pgSize=" + pageSize + "&pgNumber=" + (curPageNo + 1) + "" + param
                        + "\" hidefocus=\"hidefocus\">下一页</a> \n";
            }
        }

        return pre_str + sb.toString() + next_str;
    }

    /**
     * 获取分页字符串
     *
     * @param totalCount 总记录数
     * @param pageUrl    不带页参的url
     * @param pageCount  页数
     * @param pageSize   每页记录数
     * @param curPageNo  当前页
     * @param param      where条件:&amp;spbm=22&amp;spmc=33
     * @return 分页字符串
     */
    public static String getPlistPagestr(Integer totalCount, String pageUrl, Integer pageCount, Integer pageSize,
                                         Integer curPageNo, String param) {
        StringBuffer sb = new StringBuffer();
        param = param.trim();
        if ("-".equals(param)) {
            param = "";
        }
        pageUrl = pageUrl.replaceAll(".jhtml", "");
        if (pageCount <= 1) {
            return "";
        }
        curPageNo = curPageNo < 1 ? 1 : curPageNo;
        String next_str = "";
        String pre_str = "";
        boolean b = false;
        boolean c = false;
        for (int i = 1; i <= pageCount; i++) {
            if (curPageNo > 1) {
                pre_str = "<a  href=\"javascript:void(0)\"  value=\"" + pageUrl + "-" + pageSize + "-" + (curPageNo - 1)
                        + "" + param + ".jhtml\" class=\"prev\">上一页</a>\n";
            }
            if (curPageNo == i) {
                sb.append("<a href=\"#\" class=\"cur\">" + i + "</a>\n");
            } else {
                if (i == 1 || i == pageCount || (i > curPageNo && i <= curPageNo + 2)
                        || (i >= curPageNo - 2 && i < curPageNo)) {
                    sb.append("<a href=\"" + pageUrl + "-" + pageSize + "-" + i + "" + param + ".jhtml\">" + i
                            + "</a>\n");
                } else {
                    if (i <= curPageNo - 2) {
                        if (!b) {
                            sb.append("<span>……</span>\n");
                            b = true;
                        }
                    }
                    if (i > curPageNo + 2) {
                        if (!c) {
                            sb.append("<em>…</em>\n");
                            c = true;
                        }
                    }
                }
            }
            if (i > 1 && pageCount > curPageNo) {
                next_str = "<a  href=\"javascript:void(0)\" value=\"" + pageUrl + "-" + pageSize + "-" + (curPageNo + 1)
                        + "" + param + ".jhtml\" class=\"next\">下一页</a>\n";
            }
        }

        return pre_str + next_str;
    }

    /**
     * 判断字符串中是否包含中文
     *
     * @param str 待校验字符串
     * @return 是否为中文
     * @warn 不能校验是否为中文标点符号
     */
    public static boolean isContainChinese(String str) {
        // Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m = cnPattern.matcher(str);
        if (m.find()) {
            return true;
        }
        return false;
    }

    /**
     * 字符串数组转整型数组
     *
     * @param arrs
     * @return
     */
    public static int[] StringToInt(String[] arrs) {

        int[] ints = new int[arrs.length];
        for (int i = 0; i < arrs.length; i++) {
            ints[i] = Integer.parseInt(arrs[i]);
        }
        return ints;

    }

    /**
     * 替换
     *
     * @param srcStr
     * @param splitter
     * @return
     */
    public static String trimBothEndsChars(String srcStr, String splitter) {
        String regex = "^" + splitter + "*|" + splitter + "*$";
        return srcStr.replaceAll(regex, "");
    }

    /**
     * 查看一个字符串是否可以转换为数字
     *
     * @param str 字符串
     * @return true 可以; false 不可以
     */
    public static boolean isStr2Num(String str) {
        try {
            Integer.parseInt(str);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * 集合操作
     *
     * @param m
     * @param n
     * @param type 1：并集，0：交集，-1：差集
     * @return
     */
    public static Integer[] getCollectionSet(Integer[] m, Integer[] n, int type) {
        if (type == 1) {
            return getUnionCollection(m, n);
        } else if (type == 0) {
            return getIntersectionCollection(m, n);
        } else if (type == -1) {
            return getDifferentCollection(m, n);
        } else {
            return getUnionCollection(m, n);
        }
    }

    /**
     * 求并集
     *
     * @param m
     * @param n
     * @return
     */
    public static Integer[] getUnionCollection(Integer[] m, Integer[] n) {
        // 将数组转换为set集合
        Set<Integer> set1 = new HashSet<Integer>(Arrays.asList(m));
        Set<Integer> set2 = new HashSet<Integer>(Arrays.asList(n));

        // 合并两个集合
        set1.addAll(set2);

        Integer[] arr = {};
        return set1.toArray(arr);
    }

    /**
     * 求交集
     *
     * @param m
     * @param n
     * @return
     */
    public static Integer[] getIntersectionCollection(Integer[] m, Integer[] n) {
        List<Integer> rs = new ArrayList<Integer>();
        // 将较长的数组转换为set
        Set<Integer> set = new HashSet<Integer>(Arrays.asList(m.length > n.length ? m : n));
        // 遍历较短的数组，实现最少循环
        for (Integer i : m.length > n.length ? n : m) {
            if (set.contains(i)) {
                rs.add(i);
            }
        }
        Integer[] arr = {};
        return rs.toArray(arr);
    }

    /**
     * 求差集
     *
     * @param m
     * @param n
     * @return
     */
    public static Integer[] getDifferentCollection(Integer[] m, Integer[] n) {
        // 将较长的数组转换为set
        Set<Integer> set = new HashSet<Integer>(Arrays.asList(m.length > n.length ? m : n));

        // 遍历较短的数组，实现最少循环
        for (Integer i : m.length > n.length ? n : m) {
            // 如果集合里有相同的就删掉，如果没有就将值添加到集合
            if (set.contains(i)) {
                set.remove(i);
            } else {
                set.add(i);
            }
        }

        Integer[] arr = {};
        return set.toArray(arr);
    }

    /**
     * 检验禁忌用 检查数组交集
     *
     * @param strArrs
     * @param inArrs
     * @return
     */
    public static List<String[]> isContain(String[] strArrs, List<String[]> inArrs) {
        List<String[]> lists = new ArrayList<>();
        Integer[] intArrs = (Integer[]) ConvertUtils.convert(strArrs, Integer.class);
        for (String[] inArr : inArrs) {

            if (getIntersectionCollection(intArrs, (Integer[]) ConvertUtils.convert(inArr, Integer.class)).length == inArr.length) {
                lists.add(inArr);
            }
        }
        return lists;
    }

    /**
     * 字符串转unicode
     *
     * @param str
     * @return
     */
    public static String stringToUnicode(String str) {
        StringBuffer sb = new StringBuffer();
        char[] c = str.toCharArray();
        for (int i = 0; i < c.length; i++) {
            sb.append("\\u" + Integer.toHexString(c[i]));
        }
        return sb.toString();
    }

    /**
     * unicode转字符串
     *
     * @param unicode
     * @return
     */
    public static String unicodeToString(String unicode) {
        StringBuffer sb = new StringBuffer();
        String[] hex = unicode.split("\\\\u");
        for (int i = 1; i < hex.length; i++) {
            int index = Integer.parseInt(hex[i], 16);
            sb.append((char) index);
        }
        return sb.toString();
    }

    /**
     * 数组转List
     *
     * @param strArr
     * @return
     */
    public static List<String> arrToList(String[] strArr) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < strArr.length; i++) {
            list.add(strArr[i]);
        }
        return list;
    }

    /**
     * 判断是否是整形
     *
     * @param input
     * @return
     */
    public static boolean isInteger(String input) {
        if (input == null) {
            return false;
        }
        Matcher mer = Pattern.compile("^[+-]?[0-9]+$").matcher(input);
        return mer.find();
    }

    /**
     * 判断是否是整形
     *
     * @param input
     * @return
     */
    public static boolean isInteger(Object input) {
        if (input == null) {
            return false;
        }
        if (isEmpty(input)) {
            return false;
        }
        Matcher mer = Pattern.compile("^[+-]?[0-9]+$").matcher(input.toString());
        return mer.find();
    }

    /**
     * 判断 String 是否是 double<br>通过正则表达式判断
     *
     * @param input
     * @return
     */
    public static boolean isDouble(String input) {
        if (input == null) {
            return false;
        }
        Matcher mer = Pattern.compile("^[+-]?[0-9.]+$").matcher(input);
        return mer.find();
    }


    public static void main(String[] args) {
        System.out.println(trimHead("大家好大家好", "好"));
        System.out.println(trimHead("大家好大家好", "大家好"));
        System.out.println(trimHead("大家好大家好", "大"));
        System.out.println(trimTail("大家好大家好", "好"));
        System.out.println(trimTail("大家好大家好", "家好"));
        System.out.println(trimTail("大家好大家好", "家"));

        String tt = "　 12 3　 ";
        System.out.println("[" + trimSpace(tt) + "]");

        System.out.println(getIntervalStr("1234567890", "23", "78"));
    }
}
